/**
 * 应用主JS - 修复版本 v1.0.1
 * 修复了 currentPosition 变量引用错误
 */
document.addEventListener('DOMContentLoaded', function() {
    // 初始化应用配置
    if (!window.appConfig) {
        window.appConfig = {
            debugMode: false
        };
    }
    
    // 从服务器获取配置（如果存在）
    let appConfig = window.appConfig || {};
    
    // 验证必要的配置是否存在
    if (appConfig.repetitions === undefined || appConfig.repetitions === null) {
        throw new Error('服务器未提供重复次数配置(repetitions)');
    }
    
    // 使用服务器配置，不使用默认值
    const commandWords = appConfig.commandWords || [];
    if (commandWords.length === 0) {
        throw new Error('服务器未提供指令词列表(commandWords)或列表为空');
    }
    
    // 获取平台信息 - 优先使用服务器配置
    let platform = appConfig.platform || '';
    
    // 速度设置 - 优先使用服务器配置
    const speeds = appConfig.speeds || [];
    if (speeds.length === 0) {
        throw new Error('服务器未提供速度设置(speeds)或设置为空');
    }
    let currentSpeedIndex = 0;
    
    // 重复次数设置 - 直接使用服务器配置，不使用默认值
    const repetitions = Number(appConfig.repetitions);
    
    // 验证重复次数是否有效
    if (isNaN(repetitions) || repetitions <= 0) {
        throw new Error(`无效的重复次数: ${appConfig.repetitions}，必须是大于0的数字`);
    }
    
    // 生成完整的单词序列（包含所有重复和所有速度）
    let allWords = [];
    let allSpeeds = [];
    
    // 为每个速度生成单词序列
    for (let speedIndex = 0; speedIndex < speeds.length; speedIndex++) {
        // 为每个单词生成重复
        for (let wordIndex = 0; wordIndex < commandWords.length; wordIndex++) {
            // 根据repetitions设置添加单词，确保当repetitions为1时只添加一次
            const repeats = Number(repetitions);
            
            // 添加单词到序列
            for (let i = 0; i < repeats; i++) {
                allWords.push(commandWords[wordIndex]);
                allSpeeds.push(speeds[speedIndex]);
            }
        }
    }
    
    // 初始化变量
    let currentWordIndex = 0;
    let recordingInProgress = false;
    let recordingPaused = false;
    let uploadQueue = [];
    let isUploading = false;
    let isSubmitted = false; // 添加提交状态标志
    
    // 移除录音状态恢复相关变量
    // let hasRestoredState = false;
    
    // 全局变量
    let recorder = null;
    let waveform = null;
    let wordSegments = [];
    let uploadSessionId = null; // 添加一个上传会话ID
    let streamingEnabled = true; // 控制是否启用流式上传
    
    // 获取DOM元素
    let prevWordEl = document.getElementById('prev-word');
    let currentWordEl = document.getElementById('current-word');
    let nextWordEl = document.getElementById('next-word');
    let recordBtn = document.getElementById('record-btn');
    let prevBtn = document.getElementById('prev-btn');
    let nextBtn = document.getElementById('next-btn');
    let speedIndicator = document.getElementById('speed-indicator');
    let currentTimeEl = document.getElementById('current-time');
    let totalTimeEl = document.getElementById('total-time');
    let progressBar = document.getElementById('progress-bar');
    let wordCountEl = document.getElementById('word-count');
    let speedProgressEl = document.getElementById('speed-progress');
    let loadingIndicator = document.getElementById('loading-indicator');
    
    // 初始化语言设置（如果i18n模块存在）
    if (window.i18n) {
        window.i18n.initLanguage();
    }
    
    // 检查值是否有效 (非空、非undefined、是数字且不是NaN)
    function isValid(value) {
        return value !== null && value !== undefined && typeof value === 'number' && !isNaN(value);
    }
    
    /**
     * 更新VU电平表 - 用于可视化音频输入电平
     * @param {Float32Array} audioData 音频数据
     */
    function updateVUMeter(audioData) {
        // 如果没有VU电平表元素，不执行任何操作
        const vuMeter = document.getElementById('vu-meter');
        if (!vuMeter) return;
        
        // 计算音频数据的平均能量
        let sum = 0;
        for (let i = 0; i < audioData.length; i++) {
            sum += Math.abs(audioData[i]);
        }
        
        // 计算平均能量并转换为0-100的范围
        const average = sum / audioData.length;
        const level = Math.min(100, Math.max(0, average * 500)); // 缩放因子可以根据需要调整
        
        // 更新VU电平表的显示
        vuMeter.style.width = `${level}%`;
        
        // 根据电平值更新颜色
        if (level < 30) {
            vuMeter.style.backgroundColor = '#3498db'; // 低电平 - 蓝色
        } else if (level < 70) {
            vuMeter.style.backgroundColor = '#2ecc71'; // 中等电平 - 绿色
        } else if (level < 90) {
            vuMeter.style.backgroundColor = '#f39c12'; // 高电平 - 橙色
        } else {
            vuMeter.style.backgroundColor = '#e74c3c'; // 过高电平 - 红色
        }
    }
    
    // 波形图准备完成的处理函数
    function handleWaveformReady(duration) {
        // 显示总时长
        if (totalTimeEl) {
            totalTimeEl.textContent = formatTime(duration);
        }
        // 波形图准备完成后可能需要处理的其他逻辑
    }
    
    // 音频处理过程中的处理函数
    function handleAudioProcess(currentTime) {
        // 更新当前时间显示
        updateRecordingTime(currentTime);
    }
    
    // 初始化波形显示
    waveform = new WaveformDisplay('waveform', {
            waveColor: '#3498db',
            progressColor: '#2980b9',
            cursorColor: '#e74c3c',
            height: 150,
        minPxPerSec: 100,
        onReady: handleWaveformReady,
        onAudioprocess: handleAudioProcess,
        // 添加暂停和播放事件处理
        onPause: function() {
            console.log('波形图暂停');
        },
        onPlay: function() {
            console.log('波形图开始播放');
        }
    });
    
    // 初始化录音器
    recorder = new AudioRecorder({
        sampleRate: 16000,
        bitDepth: 16,
        channels: 1,
        onStart: handleRecordStart,
        onPause: handleRecordPause,
        onResume: handleRecordResume,
        onStop: handleRecordStop,
        onError: handleRecordError,
        onStateChange: handleRecordStateChange,
        onDataAvailable: function(data) {
            // 数据可用时的处理
            updateVUMeter(data);
        },
        onNewChunks: function(wavBlob, processed, total) {
            // 不执行任何上传操作，只记录日志
            console.log('新的音频块可用，等待点击下一词时上传');
        }
    });
    
    // 直接初始化UI和单词显示
    initializeApp();
    
    // 主应用初始化函数，立即执行
    function initializeApp() {
        // 初始化UI组件
        initUI();
        
        // 设置初始单词显示
        if (allWords.length > 0) {
            // 重置当前位置为0（第一个单词）
            currentWordIndex = 0;
            
            // 触发单词显示更新
            updateWordDisplay();
        } else {
            if (window.appConfig && window.appConfig.debugMode) {
                console.error('单词数组为空，无法显示单词');
            }
            // 显示错误提示
            currentWordEl.textContent = '配置错误：单词列表为空';
        }
        
        // 添加页面可见性变化事件处理
        document.addEventListener('visibilitychange', handleVisibilityChange);
        
        // 添加页面关闭前事件，保存录音进度
        window.addEventListener('beforeunload', function() {
            saveRecordingProgress();
        });
    }
    
    // 更新速度指示器
    function updateSpeedIndicator() {
        if (currentWordIndex < allWords.length) {
            const currentSpeed = allSpeeds[currentWordIndex];
            
            // 获取翻译后的速度文本
            const speedText = window.i18n.getSpeedText(currentSpeed);
            if (speedIndicator) {
                speedIndicator.textContent = speedText;
                // 确保speed-indicator有正确的class，无论模板中如何定义
                speedIndicator.className = 'highlight';
                speedIndicator.id = 'speed-indicator';
            }
            
            // 更新速度进度文本
            if (speedProgressEl) {
                speedProgressEl.textContent = window.i18n.translate('speedProgress');
            }
        }
    }
    
    // 格式化时间为 MM:SS 格式
    function formatTime(seconds) {
        const minutes = Math.floor(seconds / 60);
        const secs = Math.floor(seconds % 60);
        return `${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
    }
    
    // 更新单词显示
    function updateWordDisplay() {
        // 确保DOM元素存在
        if (!prevWordEl || !currentWordEl || !nextWordEl) {
            if (window.appConfig && window.appConfig.debugMode) {
                console.error('单词显示元素未找到');
            }
            return;
        }
        
        // 确保currentWordIndex在有效范围内
        if (currentWordIndex < 0 || currentWordIndex >= allWords.length) {
            console.error('currentWordIndex超出范围:', currentWordIndex, '总单词数:', allWords.length);
            // 修正为有效值
            currentWordIndex = Math.max(0, Math.min(currentWordIndex, allWords.length - 1));
            console.log('已修正为:', currentWordIndex);
        }
        
        // 获取前一个、当前和下一个单词的索引
        const prevIndex = currentWordIndex > 0 ? currentWordIndex - 1 : -1;
        const nextIndex = currentWordIndex < allWords.length - 1 ? currentWordIndex + 1 : -1;
        
        // 更新显示
        prevWordEl.textContent = prevIndex >= 0 ? allWords[prevIndex] : '';
        currentWordEl.textContent = allWords[currentWordIndex] || '';
        nextWordEl.textContent = nextIndex >= 0 ? allWords[nextIndex] : '';
        
        // 检查是否是最后一个单词
        const isLastWord = currentWordIndex === allWords.length - 1;
        
        if (isLastWord) {
            // 最后一个词时，下一词按钮显示"完成"，但上面不显示下一个词
            nextBtn.textContent = window.i18n.translate('complete');
            // 设置data-state属性标记完成状态
            nextBtn.dataset.state = 'complete';
        } else {
            // 非最后一个词时，下一词按钮显示"下一词"
            nextBtn.textContent = window.i18n.translate('nextBtn');
            // 移除状态标记
            delete nextBtn.dataset.state;
        }
        
        // 更新进度信息
        if (wordCountEl) {
            wordCountEl.textContent = `${currentWordIndex + 1}/${allWords.length}`;
        }
        
        // 更新进度条
        if (progressBar) {
            const progressPercentage = ((currentWordIndex + 1) / allWords.length) * 100;
            progressBar.style.width = `${progressPercentage}%`;
        }
        
        // 获取当前速度并更新提示文本中的速度
        const currentSpeed = allSpeeds[currentWordIndex];
        updatePromptSpeed(currentSpeed);
    }
    
    // 更新提示文本中的速度
    function updatePromptSpeed(speed) {
        if (!window.i18n) return;
        
        // 获取当前语言下的速度文本
        const speedText = window.i18n.getSpeedText(speed);
        
        // 更新速度指示器
        const speedIndicator = document.getElementById('speed-indicator');
        if (speedIndicator) {
            speedIndicator.textContent = speedText;
        }
        
        // 更新提示文本
        const promptSection = document.getElementById('prompt-section');
        if (promptSection) {
            const promptTemplate = window.i18n.translate('promptTemplate');
            const promptHtml = promptTemplate.replace('{speed}', speedText);
            promptSection.innerHTML = `<p id="prompt-text">${promptHtml}</p>`;
        }
        
        // 更新速度进度文本
        const speedProgressEl = document.getElementById('speed-progress');
        if (speedProgressEl) {
            speedProgressEl.textContent = window.i18n.translate('speedProgress');
        }
    }
    
    // 处理录音状态变更
    function handleRecordStateChange(event) {
        if (event.action === 'save') {
            if (event.success) {
                // 只在控制台记录保存成功
                console.log('录音状态已成功保存');
            } else {
                // 只在控制台记录保存失败
                console.error('保存录音状态失败', event.error);
            }
        } else if (event.action === 'restore') {
            if (event.success) {
                // 只在控制台记录恢复成功
                console.log('录音状态已成功恢复');
            } else {
                // 只在控制台记录恢复失败
                console.error('恢复录音状态失败', event.error);
            }
        } else if (event.action === 'clear') {
            if (event.success) {
                // 只在控制台记录清除成功
                console.log('录音状态已成功清除');
            } else {
                // 只在控制台记录清除失败
                console.error('清除录音状态失败', event.error);
            }
        }
    }
    
    /**
     * 检查并恢复录音状态 - 已禁用
     * 此函数已经被禁用，始终返回false表示没有恢复任何状态
     * @returns {Promise<boolean>} 始终返回false
     */
    async function checkAndRestoreRecordingState() {
        console.log('恢复录音状态功能已禁用');
        return false;
    }
    
    // 在初始化UI之后调用，不再检查状态
    async function initializeWithStateCheck() {
        // 初始化UI
        initUI();
        
        // 确保清理所有可能存在的临时状态
        clearRecordingProgress();
        
        // 确保单词数组已经填充
        if (allWords.length > 0) {
            // 重置当前位置
            currentWordIndex = 0;
            
            // 直接设置单词显示元素的内容
            if (prevWordEl && currentWordEl && nextWordEl) {
                prevWordEl.textContent = '';
                currentWordEl.textContent = allWords[0] || '';
                nextWordEl.textContent = allWords.length > 1 ? allWords[1] : '';
            }
            
            // 更新单词显示
            updateWordDisplay();
            
            // 更新进度
            if (wordCountEl) {
                wordCountEl.textContent = `1/${allWords.length}`;
            }
            
            // 更新进度条
            if (progressBar) {
                const progressPercentage = (1 / allWords.length) * 100;
                progressBar.style.width = `${progressPercentage}%`;
            }
        } else {
            console.error('单词数组为空，无法显示单词');
        }
    }
    
    // 修改处理录音按钮点击函数
    async function handleRecordButtonClick() {
        // 如果正在上传，不允许操作
        if (isUploading) {
            return;
        }
        
        // 如果已经提交过录音，不允许再次录音
        if (isSubmitted) {
            alert('已经提交过录音，请刷新页面开始新的录音');
            return;
        }
        
        // 如果已经完成所有单词且下一词按钮显示"完成"或已隐藏，不允许再次录音
        const completeText = window.i18n.translate('complete');
        if ((nextBtn.textContent === completeText || nextBtn.style.display === 'none') && wordSegments.length > 0) {
            // 显示提示
            alert(window.i18n.translate('completeAllWordsAlert'));
            return;
        }
    
        if (recorder.isRecording) {
            recorder.pause();
        } else if (recorder.audioWorkletNode || recorder.audioProcessor) {
            recorder.resume();
        } else {
            startRecording();
        }
    }
    
    // 开始录音
    async function startRecording() {
        // 移除重复调用recorder.start()
        const success = await recorder.start()
            .catch(error => {
                if (window.appConfig && window.appConfig.debugMode) {
                    console.error('录音失败:', error);
                }
                alert(window.i18n.translate('recordingError'));
                return false;
            });
        
        if (success) {
            recordingInProgress = true;
            
            // 只初始化会话ID，不启动定时器
            if (uploadSessionId === null) {
                uploadSessionId = generateConsistentSessionId();
            }
        }
        
        return success;
    }
    
    /**
     * 生成一致的会话ID
     * 首先检查localStorage中是否已有会话ID
     * 如果是Prolific平台则使用PID
     * 否则生成随机ID
     * @returns {string} 生成的会话ID
     */
    function generateConsistentSessionId() {
        // 1. 首先检查localStorage是否已有会话ID
        const storedSessionId = localStorage.getItem('recordingSessionId');
        if (storedSessionId) {
            console.log('使用本地存储的会话ID:', storedSessionId);
            return storedSessionId;
        }
        
        let sessionId = '';
        
        // 2. 针对不同平台生成特定格式的ID
        if (platform === 'prolific') {
            // 首先尝试从URL中获取PID参数
            const urlParams = new URLSearchParams(window.location.search);
            const urlPid = urlParams.get('PROLIFIC_PID');
            
            if (urlPid) {
                // 使用URL中的PID作为会话ID
                console.log('从URL获取PID:', urlPid);
                sessionId = `prolific_${urlPid}`;
            } else {
                // 如果URL中没有，再尝试从DOM元素获取
                const prolificParamsEl = document.getElementById('prolific-params');
                if (prolificParamsEl) {
                    const pid = prolificParamsEl.getAttribute('data-prolific-pid') || '';
                    
                    if (pid) {
                        // 使用元素中的PID作为会话ID
                        console.log('从DOM元素获取PID:', pid);
                        sessionId = `prolific_${pid}`;
                    } else {
                        // 无PID时使用固定前缀
                        sessionId = 'prolific_unknown';
                    }
                } else {
                    // 找不到Prolific参数元素，使用固定前缀
                    sessionId = 'prolific_unknown';
                }
            }
        } else {
            // 非Prolific平台使用随机ID
            sessionId = generateRandomId();
        }
        
        // 3. 将生成的ID保存到localStorage
        localStorage.setItem('recordingSessionId', sessionId);
        console.log('已生成并保存新的会话ID:', sessionId);
        
        return sessionId;
    }
    
    /**
     * 生成随机ID
     * 使用随机字符串，确保唯一性
     */
    function generateRandomId() {
        const randomPart = Math.random().toString(36).substring(2, 10) + 
                          Math.random().toString(36).substring(2, 10);
        return `session_${randomPart}`;
    }
    
    /**
     * 清除会话ID
     * 在录音完成上传后调用，确保下次生成新的会话ID
     */
    function clearSessionId() {
        localStorage.removeItem('recordingSessionId');
        console.log('已清除会话ID');
    }
    
    // 处理录音开始
    function handleRecordStart() {
        recordBtn.textContent = window.i18n.translate('pause');
        recordBtn.classList.add('recording');
        // 移除任何状态标记
        delete recordBtn.dataset.state;
        
        // 启用上一词和下一词按钮
        prevBtn.disabled = false;
        nextBtn.disabled = false;
        
        // 清空波形图
        waveform.empty();
        waveform.clearMarkers();
        
        // 清空标记数据
        wordSegments = [];
        
        // 获取当前时间（0秒，刚开始录音）
        const currentTime = 0;
        
        // 获取当前显示的单词
        const word = currentWordEl.textContent.trim();
        
        // 添加当前单词作为第一个标记（仅用于上传，不影响显示）
        const newMarker = {
            word: word,
            startTime: currentTime,
            endTime: null,
            duration: null,
            speed: allSpeeds[currentWordIndex]
        };
        
        // 添加到标记数组
        wordSegments.push(newMarker);
        
        // 获取分析器节点
        const analyser = recorder.getAnalyser();
        
        // 开始实时波形动画（仅当分析器可用时）
        if (analyser) {
            try {
        waveform.startLiveWaveform(
                    analyser,
            () => recorder.getCurrentTime(),
            updateRecordingTime
        );
            } catch (error) {
                console.error('启动波形显示失败:', error);
                // 仍然需要更新录音时间
                updateRecordingTime(0);
            }
        } else {
            console.warn('分析器节点不可用，波形显示将不会启动');
            // 仍然需要更新录音时间
            updateRecordingTime(0);
        }
        
        // 保存录音进度
        saveRecordingProgress();
        
        // 更新单词标记区
        updateMarkersList();
    }
    
    // 处理录音暂停
    function handleRecordPause() {
        if (recordBtn) {
            // 将按钮文本设置为"继续"
            const currentLang = window.i18n.getCurrentLanguage();
            recordBtn.textContent = window.i18n.translate('resume');
            recordBtn.dataset.state = 'paused';
            recordBtn.classList.remove('recording');
            
            // 禁用上一词和下一词按钮
            prevBtn.disabled = true;
            nextBtn.disabled = true;
            
            // 暂停波形动画但保留波形历史
            waveform.pauseLiveWaveform();
            
            // 确保时间显示正确更新到暂停时刻
            const pauseTime = recorder.getCurrentTime();
            updateRecordingTime(pauseTime);
            
            // 停止波形图动画，确保波形停止移动
            if (waveform.wavesurfer) {
                waveform.wavesurfer.pause();
            }
            
            // 保存录音进度
            saveRecordingProgress();
        }
    }
    
    // 处理录音继续
    function handleRecordResume() {
        recordBtn.textContent = window.i18n.translate('pause');
        recordBtn.classList.add('recording');
        // 移除暂停状态标记
        delete recordBtn.dataset.state;
        
        // 启用上一词和下一词按钮
        prevBtn.disabled = false;
        nextBtn.disabled = false;
        
        // 立即更新UI显示的时间
        const currentTime = recorder.getCurrentTime();
        updateRecordingTime(currentTime);
        
        // 获取分析器节点
        const analyser = recorder.getAnalyser();
        
        // 继续波形动画（仅当分析器可用时）
        if (analyser) {
            try {
        waveform.startLiveWaveform(
                    analyser,
            () => recorder.getCurrentTime(),
            updateRecordingTime
        );
            } catch (error) {
                console.error('恢复波形显示失败:', error);
            }
        } else {
            console.warn('分析器节点不可用，波形显示将不会恢复');
        }
        
        // 保存录音进度
        saveRecordingProgress();
    }
    
    // 处理录音停止
    function handleRecordStop(audioBlob) {
        recordingInProgress = false;
        
        // 如果启用了流式上传，且还没有提交最终块，则发送最终块
        if (streamingEnabled && uploadSessionId && !isSubmitted) {
            finalizeSreamUpload(audioBlob);
        } else if (!streamingEnabled && !isSubmitted) {
            // 没有启用流式上传，使用原始的一次性上传
            if (audioBlob) {
                // 处理录音结果
                processRecordingResult(audioBlob);
            }
        } else {
            console.log('已经上传过最终块，跳过上传');
        }
        
        recordBtn.textContent = window.i18n.translate('recordBtn');
        recordBtn.classList.remove('recording');
        // 移除任何状态标记
        delete recordBtn.dataset.state;
        
        // 禁用上一词和下一词按钮
        prevBtn.disabled = true;
        nextBtn.disabled = true;
        
        // 停止波形动画
        waveform.stopLiveWaveform();
        
        // 加载音频到波形图
        waveform.loadAudio(audioBlob);
        
        // 清除录音进度（录音已完成，不需要保存进度）
        clearRecordingProgress();
    }
    
    // 完成流式上传
    function finalizeSreamUpload(audioBlob) {
        if (!audioBlob || isUploading || isSubmitted) {
            console.error('无法完成上传:', {
                audioBlobExists: !!audioBlob,
                audioBlobSize: audioBlob ? audioBlob.size : 0,
                isUploading: isUploading,
                isSubmitted: isSubmitted
            });
            
            if (!audioBlob) {
                alert(window.i18n.translate('noAudioData') || '没有录音数据可上传');
            } else if (isUploading) {
                alert(window.i18n.translate('uploadInProgress') || '正在上传中，请稍候');
            } else if (isSubmitted) {
                alert(window.i18n.translate('alreadySubmitted') || '已经提交过录音');
            }
            return;
        }
        
        // 标记上传状态，避免重复上传
        isUploading = true;
        
        // 显示加载指示器
        showLoadingIndicator();
        console.log('开始上传最终音频块，大小:', audioBlob.size);
        
        // 创建FormData对象
        const formData = new FormData();
        formData.append('audio_chunk', audioBlob, 'final_chunk.wav');
        formData.append('session_id', uploadSessionId);
        formData.append('chunk_index', wordSegments.length);
        formData.append('is_final', 'true');
        
        // 获取本地保存的元数据，如果有的话
        let metadata;
        const metadataJSON = localStorage.getItem('recordingMetadata');
        if (metadataJSON) {
            try {
                metadata = JSON.parse(metadataJSON);
                console.log('使用本地保存的元数据:', metadata);
            } catch (e) {
                console.error('解析本地元数据失败:', e);
                // 如果解析失败，创建新的元数据
                metadata = createMetadata(audioBlob);
            }
        } else {
            // 如果没有本地元数据，创建新的
            metadata = createMetadata(audioBlob);
        }
        
        // 将完整元数据添加到表单
        formData.append('metadata', JSON.stringify(metadata));
        
        console.log('上传最终音频块并触发拼接...');
        
        // 设置请求超时为30秒
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), 30000);
        
        // 发送请求
        fetch('/api/upload_chunk', {
            method: 'POST',
            body: formData,
            signal: controller.signal
        })
        .then(response => {
            clearTimeout(timeoutId);
            hideLoadingIndicator();
            
            if (!response.ok) {
                return response.text().then(text => {
                    throw new Error(`最终块上传失败 (${response.status}): ${text}`);
                });
            }
            console.log('服务器响应成功，状态码:', response.status);
            return response.json();
        })
        .then(data => {
            console.log('最终块上传成功，服务器已拼接音频:', data);
            isSubmitted = true;
            
            // 处理完成后的UI更新
            handleUploadSuccess(data);
            
            // 清除本地录音进度
            clearRecordingProgress();
            
            // 如果在Prolific平台，创建重定向URL
            if (platform === 'prolific') {
                // 默认的完成代码，确保总有一个可用
                const defaultCompletionCode = 'C15MASW8';
                let prolificRedirectUrl = null;
                
                try {
                    // 尝试从不同的返回数据格式中获取跳转URL
                    if (data && data.completion_code) {
                        // 如果直接返回了完成代码
                        prolificRedirectUrl = `https://app.prolific.com/submissions/complete?cc=${data.completion_code}`;
                        console.log('从completion_code构建跳转URL:', prolificRedirectUrl);
                    } else if (data && data.completionUrl) {
                        // 如果返回了完整的跳转URL
                        prolificRedirectUrl = data.completionUrl;
                        console.log('使用服务器返回的completionUrl:', prolificRedirectUrl);
                    } else if (metadata && metadata.completionCode) {
                        // 使用元数据中的完成代码
                        prolificRedirectUrl = `https://app.prolific.com/submissions/complete?cc=${metadata.completionCode}`;
                        console.log('使用元数据中的completionCode构建跳转URL:', prolificRedirectUrl);
        } else {
                        // 使用默认的完成代码
                        prolificRedirectUrl = `https://app.prolific.com/submissions/complete?cc=${defaultCompletionCode}`;
                        console.log('使用默认completionCode构建跳转URL:', prolificRedirectUrl);
                    }
                    
                    // 如果没有成功构建URL，使用默认完成代码
                    if (!prolificRedirectUrl) {
                        prolificRedirectUrl = `https://app.prolific.com/submissions/complete?cc=${defaultCompletionCode}`;
                        console.log('使用默认completionCode构建跳转URL:', prolificRedirectUrl);
                    }
                } catch (error) {
                    console.error('构建Prolific跳转URL出错:', error);
                    // 出错时使用默认完成代码
                    prolificRedirectUrl = `https://app.prolific.com/submissions/complete?cc=${defaultCompletionCode}`;
                    console.log('出错后使用默认completionCode构建跳转URL:', prolificRedirectUrl);
                }
                
                // 确保始终有一个有效的URL
                if (!prolificRedirectUrl) {
                    prolificRedirectUrl = `https://app.prolific.com/submissions/complete?cc=${defaultCompletionCode}`;
                }
                
                // 弹出alert提示录音完成，并在用户点击确定后立即跳转
                alert('录音已成功完成！点击确定返回Prolific。');
                
                // 直接跳转，无需等待
                try {
                    window.location.href = prolificRedirectUrl;
                } catch (e) {
                    console.error('跳转到Prolific失败:', e);
                    alert('跳转失败，请点击确定重试');
                    window.location.href = prolificRedirectUrl;
                }
        } else {
                // 如果不是Prolific平台，只弹出提示
                alert('录音已成功完成！');
            }
        })
        .catch(error => {
            clearTimeout(timeoutId);
            console.error('最终块上传错误:', error);
            hideLoadingIndicator();
            showMessage(window.i18n.translate('uploadError'), 'error');
            
            // 重置上传状态，允许重试
            isUploading = false;
            isSubmitted = false;
            
            // 显示错误提示
            alert('上传失败: ' + error.message + '\n请点击"完成"按钮重试');
        });
    }
    
    // 创建元数据对象
    function createMetadata(audioBlob) {
        const deviceInfo = collectDeviceInfo();
        
        // 为所有词段准备完整的元数据
        const formattedSegments = wordSegments.map(segment => ({
            word: segment.word,
            startTime: segment.startTime,
            endTime: segment.endTime,
            duration: segment.duration,
            speed: segment.speed || '正常'
        }));
        
        // 创建完整的元数据
        const metadata = {
            wordSegments: formattedSegments,
            audioFormat: {
                sampleRate: 16000,
                bitDepth: 16,
                channels: 1
            },
            deviceInfo: deviceInfo,
            recordingStats: {
                totalDuration: recorder ? recorder.getCurrentTime() : 0,
                segmentsCount: wordSegments.length,
                recordingStartTime: localStorage.getItem('recordingStartTime') || new Date().toISOString()
            },
            platform: platform
        };
        
        // 如果是Prolific平台，添加Prolific相关信息
        if (platform === 'prolific') {
            const prolificParamsEl = document.getElementById('prolific-params');
            if (prolificParamsEl) {
                metadata.prolificPID = prolificParamsEl.getAttribute('data-prolific-pid') || '';
                metadata.prolificStudyID = prolificParamsEl.getAttribute('data-prolific-study-id') || '';
                metadata.prolificSessionID = prolificParamsEl.getAttribute('data-prolific-session-id') || '';
                metadata.completionCode = 'C15MASW8';
            }
        }
        
        return metadata;
    }
    
    // 收集设备和环境信息
    function collectDeviceInfo() {
        const deviceInfo = {
            // 屏幕信息（服务器端无法获取）
            screen: {
                width: window.screen.width,
                height: window.screen.height,
                availWidth: window.screen.availWidth,
                availHeight: window.screen.availHeight,
                colorDepth: window.screen.colorDepth,
                pixelDepth: window.screen.pixelDepth,
                orientation: window.screen.orientation ? window.screen.orientation.type : ''
            },
            
            // 时间信息
            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
            timezoneOffset: new Date().getTimezoneOffset(),
            
            // 网络信息（服务器端无法准确获取）
            network: {
                online: navigator.onLine,
                // 尝试获取连接信息（如果可用）
                connectionType: navigator.connection ? navigator.connection.effectiveType : 'unknown',
                downlink: navigator.connection ? navigator.connection.downlink : 'unknown',
                rtt: navigator.connection ? navigator.connection.rtt : 'unknown',
                saveData: navigator.connection ? navigator.connection.saveData : 'unknown'
            },
            
            // 音频设备信息（服务器端无法获取）
            audioInputDevices: [],
            
            // 硬件信息（服务器端无法获取）
            hardware: {
                deviceMemory: navigator.deviceMemory || 'unknown',
                hardwareConcurrency: navigator.hardwareConcurrency || 'unknown'
            },
            
            // 触摸设备检测（服务器端无法准确获取）
            isTouchDevice: ('ontouchstart' in window) || (navigator.maxTouchPoints > 0) || (navigator.msMaxTouchPoints > 0)
        };
        
        // 尝试获取音频设备信息
        if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
            navigator.mediaDevices.enumerateDevices()
                .then(devices => {
                    const audioInputs = devices.filter(device => device.kind === 'audioinput');
                    deviceInfo.audioInputDevices = audioInputs.map(device => ({
                        deviceId: device.deviceId,
                        label: device.label || '未知麦克风'
                    }));
                })
                .catch(err => {
                    if (window.appConfig && window.appConfig.debugMode) {
                        console.error('无法枚举设备:', err);
                    }
                });
        }
        
        return deviceInfo;
    }
    
    // 重置录音状态
    function resetRecording() {
        // 重置录音器
        recorder.reset();
        
        // 清空波形图
        waveform.empty();
        waveform.clearMarkers();
        
        // 清空标记数据
        wordSegments = [];
        
        // 更新UI
        updateMarkersList();
        currentTimeEl.textContent = '00:00';
        totalTimeEl.textContent = '00:00';
        
        // 禁用上一词和下一词按钮
        prevBtn.disabled = true;
        nextBtn.disabled = true;
        
        // 如果已提交，保持录音按钮禁用状态
        if (!isSubmitted) {
            recordBtn.disabled = false;
        }
        
        // 重置按钮文本
        recordBtn.textContent = window.i18n.translate('recordBtn');
        nextBtn.textContent = window.i18n.translate('nextBtn');
        
        // 清除所有按钮的状态标记
        delete recordBtn.dataset.state;
        delete nextBtn.dataset.state;
        delete prevBtn.dataset.state;
        
        recordBtn.classList.remove('recording');
    }
    
    // 返回上一个词
    function prevWord() {
        // 如果录音暂停中，自动继续录音
        if (!recorder.isRecording && recorder.audioProcessor) {
            recorder.resume();
        }
        
        // 获取点击"上一词"按钮时的当前时间（将作为新的开始时间）
        // 根据录音状态选择正确的时间源
        const currentTime = recorder.isRecording ? recorder.getCurrentTime() : waveform.getCurrentTime();
        // 移动到上一个位置
        currentWordIndex--;
        
        // 确保不小于0
        if (currentWordIndex < 0) {
            currentWordIndex = 0;
        }
        
        // 更新单词显示
        updateWordDisplay();
        
        if (wordSegments.length > 0) {
            // 移除当前词的元数据
            if (wordSegments.length > 0) {
                const removedCurrentMarker = wordSegments.pop();
            }
            
            // 移除上一词的元数据（之后会重新创建）
            if (wordSegments.length > 0) {
                const removedPrevMarker = wordSegments.pop();
            }
            
            // 如果在录音中，调整录音器的累计时间
            if (recorder.isRecording || recorder.audioProcessor) {
                // 回滚波形到新的时间点
                waveform.rollbackWaveform(currentTime);
                
                // 添加两个空白波形条作为视觉分隔
                if (recorder.isRecording) {
                    waveform.addEmptyBars(2);
                }
            }
        }
        
        // 在当前位置添加新元数据（即上一词的新元数据）
        if (recorder.isRecording || recorder.audioProcessor) {
            // 获取当前显示的单词（现在是上一个词）
            const currentWord = currentWordEl.textContent.trim();
            
            if (currentWord) {
                // 创建新标记对象，开始时间为当前时间
                const newMarker = {
                    word: currentWord,
                    startTime: currentTime,
                    endTime: null,
                    duration: null,
                    speed: allSpeeds[currentWordIndex]
                };
                
                // 添加到标记数组
                wordSegments.push(newMarker);
            }
        }
        
        // 恢复下一词按钮文本
        if (nextBtn.textContent === window.i18n.translate('submit')) {
            nextBtn.textContent = window.i18n.translate('nextBtn');
        }
        
        // 保存录音进度
        saveRecordingProgress();
    }
    
    // 更新标记列表
    function updateMarkersList() {
        // 此函数已不再需要，但保留空实现以避免错误
        // 原来的功能是更新时间标记列表，现在界面上已经不显示这些信息
    }
    
    // 初始化UI和事件监听器 
    function initUI() {
        // 初始化UI相关参数
        wordDisplay = document.getElementById('word-display');
        currentWordEl = document.getElementById('current-word');
        wordTimingEl = document.getElementById('word-timing');
        prevWordEl = document.getElementById('prev-word');
        nextWordEl = document.getElementById('next-word');
        wordCountEl = document.getElementById('word-count');
        progressBar = document.getElementById('progress-bar');
        speedIndicator = document.getElementById('speed-indicator');
        recordBtn = document.getElementById('record-btn');
        prevBtn = document.getElementById('prev-btn');
        nextBtn = document.getElementById('next-btn');
        
        // 清除现有的事件监听器，防止重复绑定
        try {
            if (recordBtn) {
                const newRecordBtn = recordBtn.cloneNode(true);
                recordBtn.parentNode.replaceChild(newRecordBtn, recordBtn);
                recordBtn = newRecordBtn;
            }
            
            if (prevBtn) {
                const newPrevBtn = prevBtn.cloneNode(true);
                prevBtn.parentNode.replaceChild(newPrevBtn, prevBtn);
                prevBtn = newPrevBtn;
            }
            
            if (nextBtn) {
                const newNextBtn = nextBtn.cloneNode(true);
                nextBtn.parentNode.replaceChild(newNextBtn, nextBtn);
                nextBtn = newNextBtn;
                console.log("下一词按钮已重新创建，移除所有事件监听器");
            }
        } catch (error) {
            console.error("重置按钮事件监听器时出错:", error);
        }
        
        // 设置按钮初始状态
        if (prevBtn) prevBtn.disabled = true;
        if (nextBtn) nextBtn.disabled = true;
        
        // 添加事件监听
        if (nextBtn) {
            nextBtn.addEventListener('click', function(e) {
                // 防止默认行为和冒泡
                e.preventDefault();
                e.stopPropagation();
                
                // 记录点击时间，防止连续点击
                const now = Date.now();
                if (this._lastClickTime && (now - this._lastClickTime < 1000)) {
                    console.log('防止快速连续点击，忽略此次点击');
                    alert('提示：请勿快速连续点击');
                    return;
                }
                this._lastClickTime = now;
                
                // 如果正在处理，不允许再次点击
            if (this.dataset.processing === 'true') {
                    console.log('按钮正在处理中，忽略点击');
                    alert('提示：请勿快速连续点击');
                return;
            }
            
                // 设置处理标记，防止连续点击
            this.dataset.processing = 'true';
            
                // 添加调试输出
                console.log('下一词按钮被点击，当前索引:', currentWordIndex);
                
                try {
                    // 根据按钮当前文本判断是完成还是下一个词
                    const completeText = window.i18n.translate('complete');
                    if (this.textContent === completeText) {
                        console.log('执行完成录音操作');
                        
                        // 添加调试信息
                        console.log('录音对象状态:', {
                            isRecording: recorder.isRecording,
                            audioBlobExists: !!recorder.audioBlob,
                            audioBlobSize: recorder.audioBlob ? recorder.audioBlob.size : 0,
                            uploadSessionId: uploadSessionId,
                            isUploading: isUploading,
                            isSubmitted: isSubmitted
                        });
                        
                        // 确保有音频数据可用
                        if (!recorder.audioBlob) {
                            console.warn('没有可用的音频数据，尝试从recorder中获取');
                            try {
                                // 尝试手动获取音频数据
                                const audioChunks = recorder.getAudioChunks();
                                if (audioChunks) {
                                    console.log('成功获取音频块，大小:', audioChunks.size);
                                    finalizeSreamUpload(audioChunks);
                                } else {
                                    console.error('无法获取音频数据，提示用户');
                                    alert(window.i18n.translate('noAudioData') || '无法获取录音数据，请重试或刷新页面');
                                }
                            } catch (e) {
                                console.error('获取音频数据时出错:', e);
                                alert(window.i18n.translate('audioError') || '处理录音数据时出错，请重试');
                            }
            } else {
                            // 正常调用完成上传
                            finalizeSreamUpload(recorder.audioBlob);
                        }
                    } else {
                        console.log('执行下一词操作');
                nextWord();
            }
                } catch (error) {
                    console.error('处理下一词按钮点击时出错:', error);
                } finally {
            // 设置一个短暂的延迟后取消处理标记
            setTimeout(() => {
                delete this.dataset.processing;
                        console.log('下一词按钮处理完成，可以再次点击');
                    }, 500);
                }
            });
            console.log("已为下一词按钮添加新的点击事件监听器");
        } else {
            console.warn("未找到下一词按钮元素，无法添加事件监听器");
        }
        
        // 为录音按钮添加事件监听器
        if (recordBtn) {
            recordBtn.addEventListener('click', function(e) {
                // 防止默认行为和冒泡
                e.preventDefault();
                e.stopPropagation();
                
                // 记录点击时间，防止连续点击
                const now = Date.now();
                if (this._lastClickTime && (now - this._lastClickTime < 500)) {
                    console.log('防止快速连续点击录音按钮，忽略此次点击');
                    alert('提示：请勿快速连续点击');
                    return;
                }
                this._lastClickTime = now;
                
                // 如果正在处理，不允许再次点击
                if (this.dataset.processing === 'true') {
                    console.log('录音按钮正在处理中，忽略点击');
                    alert('提示：请勿快速连续点击');
                    return;
                }
                
                // 设置处理标记，防止连续点击
                this.dataset.processing = 'true';
                
                try {
                    // 调用录音切换逻辑
                    toggleRecording();
                } catch (error) {
                    console.error('处理录音按钮点击时出错:', error);
                } finally {
            // 设置一个短暂的延迟后取消处理标记
            setTimeout(() => {
                delete this.dataset.processing;
                        console.log('录音按钮处理完成，可以再次点击');
                    }, 500);
                }
            });
            console.log("已为录音按钮添加新的点击事件监听器");
        }
        
        // 为上一词按钮添加事件监听器
        if (prevBtn) {
            prevBtn.addEventListener('click', function(e) {
                // 防止默认行为和冒泡
                e.preventDefault();
                e.stopPropagation();
                
                // 记录点击时间，防止连续点击
                const now = Date.now();
                if (this._lastClickTime && (now - this._lastClickTime < 1000)) {
                    console.log('防止快速连续点击上一词按钮，忽略此次点击');
                    alert('提示：请勿快速连续点击');
                    return;
                }
                this._lastClickTime = now;
                
                // 如果正在处理，不允许再次点击
                if (this.dataset.processing === 'true') {
                    console.log('上一词按钮正在处理中，忽略点击');
                    alert('提示：请勿快速连续点击');
                    return;
                }
                
                // 设置处理标记，防止连续点击
                this.dataset.processing = 'true';
                
                try {
                    // 调用上一词逻辑
                    prevWord();
                } catch (error) {
                    console.error('处理上一词按钮点击时出错:', error);
                } finally {
                    // 设置一个短暂的延迟后取消处理标记
                    setTimeout(() => {
                        delete this.dataset.processing;
                        console.log('上一词按钮处理完成，可以再次点击');
                    }, 500);
                }
            });
            console.log("已为上一词按钮添加新的点击事件监听器");
        }
        
        // 初始化单词计数显示
        if (wordCountEl) {
            wordCountEl.textContent = `0/${allWords.length}`;
        }
        
        // 初始化进度条
        if (progressBar) {
            progressBar.style.width = '0%';
        }
    }
    
    // 初始化
    async function init() {
        try {
            console.log('初始化录音应用...');
            
            // 确保所有监听器在每次初始化时都是全新的
            document.removeEventListener('visibilitychange', handleVisibilityChange);
            document.addEventListener('visibilitychange', handleVisibilityChange);
            console.log('已重新注册页面可见性变化监听器');
            
            // 删除保存录音开始时间的代码
            // if (!localStorage.getItem('recordingStartTime')) {
            //     localStorage.setItem('recordingStartTime', new Date().toISOString());
            // }
            
            // 初始化I18n (重要：提前初始化i18n，确保翻译可用)
            if (window.i18n && typeof window.i18n.initLanguage === 'function') {
                console.log('初始化多语言支持...');
                try {
                    await window.i18n.initLanguage();
                    console.log('多语言初始化成功，当前语言:', window.i18n.getCurrentLanguage());
                } catch (langError) {
                    console.error('多语言初始化失败:', langError);
                }
            } else {
                console.warn('找不到i18n模块，将使用默认语言');
            }
            
            // 生成一致的会话ID
            uploadSessionId = generateConsistentSessionId();
            console.log('使用会话ID:', uploadSessionId);
            
            // 获取应用配置
            if (window.appConfig) {
                appConfig = window.appConfig;
                console.log('应用配置:', appConfig);
            }
            
            // 检测平台
            const urlParams = new URLSearchParams(window.location.search);
            if (urlParams.has('PROLIFIC_PID') || urlParams.has('prolific_pid')) {
                platform = 'prolific';
                console.log('检测到Prolific平台');
            } else {
                platform = 'web';
                console.log('检测到Web平台');
            }
            
            // 初始化录音器
            await createRecorder();
            
            // 初始化UI元素和事件监听器 - 重要：事件监听器会在这里被重新绑定
            initUI();
            console.log('UI元素和事件监听器已初始化');
            
            // 初始化波形显示
            waveform = new WaveformDisplay('waveform');
            
            // 加载词汇列表
            if (typeof allWords !== 'undefined' && Array.isArray(allWords) && allWords.length > 0) {
                console.log(`加载了${allWords.length}个词汇`);
            } else {
                console.log('未找到词汇列表，使用默认词汇');
                allWords = ['苹果', '香蕉', '橙子', '葡萄', '西瓜', '草莓'];
            }
            
            // 始终使用新的录音状态，不再尝试恢复
            // 更新词汇显示
            updateWordDisplay();
            
            // 检查是否启用了流式上传
            streamingEnabled = true;
            
            // 初始化加载指示器
            loadingIndicator = document.getElementById('loading-indicator');
            if (!loadingIndicator) {
                loadingIndicator = document.createElement('div');
                loadingIndicator.id = 'loading-indicator';
                loadingIndicator.className = 'loading-indicator';
                loadingIndicator.style.display = 'none';
                document.body.appendChild(loadingIndicator);
            }
            
            // 更新UI元素的文本
            updateUITexts();
            
            console.log('应用初始化完成');
        } catch (error) {
            console.error('初始化失败:', error);
        }
    }
    
    // 更新UI元素的文本
    function updateUITexts() {
        try {
            if (!window.i18n) return;
            
            // 更新按钮文本
            if (recordBtn) recordBtn.textContent = window.i18n.translate('recordBtn');
            if (prevBtn) prevBtn.textContent = window.i18n.translate('prevBtn');
            if (nextBtn) nextBtn.textContent = window.i18n.translate('nextBtn');
            
            // 根据当前单词索引确定是否显示"完成"
            if (nextBtn && currentWordIndex === allWords.length - 1) {
                nextBtn.textContent = window.i18n.translate('complete');
            }
            
            // 更新速度指示器
            if (currentWordIndex < allWords.length) {
                updatePromptSpeed(allSpeeds[currentWordIndex]);
            }
            
            console.log('UI文本已更新为当前语言');
        } catch (error) {
            console.error('更新UI文本时出错:', error);
        }
    }
    
    // 处理页面可见性变化
    function handleVisibilityChange() {
        if (document.visibilityState === 'hidden') {
            // 页面隐藏时，不再保存录音进度
            console.log('页面隐藏，但不保存任何状态');
        } else if (document.visibilityState === 'visible') {
            // 页面可见时，更新界面显示
            console.log('页面可见，更新界面');
        }
    }
    
    // 清除录音进度 - 保留此函数，但简化它
    function clearRecordingProgress() {
        // 保留preferredLanguage和会话ID，清除其他所有项
        const preferredLanguage = localStorage.getItem('preferredLanguage');
        const sessionId = localStorage.getItem('recordingSessionId');
        localStorage.clear();
        
        // 恢复语言偏好设置
        if (preferredLanguage) {
            localStorage.setItem('preferredLanguage', preferredLanguage);
        }
        
        // 重新存储会话ID（如果需要的话）
        // 注意：这里保留会话ID是为了让用户可以继续使用同一个会话
        // 只有在录音完全上传成功后才会调用clearSessionId清除会话ID
        if (sessionId) {
            localStorage.setItem('recordingSessionId', sessionId);
        }
        
        console.log('录音相关数据已清除，但保留了语言偏好和会话ID');
    }
    
    // 保存录音进度 - 已禁用，但保留空函数避免引用错误
    function saveRecordingProgress() {
        // 此功能已禁用，函数保留为空以避免引用错误
        // console.log('保存录音进度功能已禁用');
        return false;
    }
    
    /**
     * 恢复录音进度 - 已禁用
     * 此函数已被禁用，始终返回false表示没有恢复任何进度
     * @returns {boolean} 始终返回false
     */
    function restoreRecordingProgress() {
        console.log("恢复功能已禁用");
        return false;
    }
    
    // 显示恢复录音进度对话框
    function showRestorePrompt() {
        return Promise.resolve(false);
    }
    
    /**
     * 恢复录音会话 - 已禁用
     * 此函数已被禁用，始终返回false表示没有恢复任何会话
     * @returns {Promise<boolean>} 始终返回false的Promise
     */
    async function resumeRecordingSession() {
        console.log("恢复录音会话功能已禁用");
        return false;
    }
    
    // 移动到下一个词
    let isNextWordProcessing = false; // 防止nextWord函数被重复调用的标记
    
    function nextWord() {
        // 防止重复调用
        if (isNextWordProcessing) {
            console.warn("nextWord函数正在执行中，忽略重复调用");
            return;
        }
        
        // 设置正在处理的标记
        isNextWordProcessing = true;
        
        try {
            // 记录函数调用时间，用于调试
            const callTime = new Date().toISOString();
            console.log(`[${callTime}] nextWord函数开始执行`);
            
            // 详细记录当前状态
            console.log('当前状态:', {
                recordingInProgress,
                currentWordIndex,
                wordSegmentsLength: wordSegments.length,
                isUploading,
                isSubmitted,
                recorderState: recorder ? {
                    isRecording: recorder.isRecording,
                    isPaused: recorder.isPaused,
                    hasAudioProcessor: !!recorder.audioProcessor
                } : 'recorder未初始化'
            });
            
            // 如果没在录音，检查是否是恢复状态
            if (!recordingInProgress) {
                console.log('未处于录音状态，检查是否是恢复状态');
                
                // 如果有词段数据，可能是恢复后的状态，允许继续
                if (wordSegments.length > 0) {
                    console.log('检测到词段数据，可能是恢复状态，允许继续处理');
                    recordingInProgress = true;
                } else {
                    console.log('未处于录音状态且无词段数据，nextWord操作被取消');
                    return;
                }
            }
            
            // 检查索引与词段数量的一致性，处理恢复后可能出现的错位问题
            if (wordSegments.length > 0 && currentWordIndex !== wordSegments.length - 1) {
                console.warn(`检测到索引与词段数量不一致! 当前索引=${currentWordIndex}, 词段数量=${wordSegments.length}`);
                
                // 根据情况调整
                if (wordSegments.length === currentWordIndex) {
                    console.log('正常情况：当前索引等于词段数量，继续处理');
                } else if (wordSegments.length < currentWordIndex) {
                    console.warn('检测到索引超前于词段数量，可能是恢复状态错位，填充空缺词段');
                    
                    // 填充缺失的词段，确保每个索引都有对应的词段
                    while (wordSegments.length < currentWordIndex) {
                        const missingWord = allWords[wordSegments.length] || 'unknown';
                        const dummySegment = {
                            word: missingWord,
                            startTime: 0,
                            endTime: 0,
                            duration: 0,
                            speed: '正常',
                            isDummy: true // 标记为填充的虚拟词段
                        };
                        wordSegments.push(dummySegment);
                        console.log(`已填充虚拟词段: ${missingWord}`);
                    }
                } else if (wordSegments.length > currentWordIndex + 1) {
                    console.warn('检测到词段数量超过索引+1，可能出现数据多余，调整索引');
                    // 将索引设置为词段数量-1，确保下一个词正确处理
                    currentWordIndex = wordSegments.length - 1;
                    console.log(`调整索引为: ${currentWordIndex}`);
                }
            }
            
            console.log("执行nextWord函数，当前索引:", currentWordIndex, "总单词数:", allWords.length);
            
            // 在单词索引变更前记录当前索引
            const startIndex = currentWordIndex;
        
        // 获取当前时间
        const currentTime = recorder.isRecording ? recorder.getCurrentTime() : waveform.getCurrentTime();
        
        // 如果当前正在录音，添加两个空白波形条作为标记
        if (recorder.isRecording) {
            waveform.addEmptyBars(2);
        }
        
        // 获取当前显示的单词
        const word = currentWordEl.textContent.trim();
        const speed = allSpeeds[currentWordIndex];
        
        // 更新最后一个词段的结束时间
        if (wordSegments.length > 0) {
            // 获取最后一个词段
            const lastSegment = wordSegments[wordSegments.length - 1];
            
            // 更新结束时间和持续时间
            lastSegment.endTime = currentTime;
            lastSegment.duration = currentTime - lastSegment.startTime;
        }
        
        // 检查是否是最后一个单词，且按钮显示"完成"
        const isLastWord = currentWordIndex === allWords.length - 1;
        const isCompleteButton = nextBtn.textContent === window.i18n.translate('complete');
                
            console.log("词段处理前，当前词段数:", wordSegments.length);
        
        // 只有在非暂停状态下才执行添加新标记
        if (recordingInProgress && !recordBtn.dataset.state) {
            // 创建新的标记
            const newSegment = {
                word: word,
                startTime: currentTime,
                endTime: null,
                duration: null,
                speed: speed
            };
            
            // 添加到标记数组
            wordSegments.push(newSegment);
                    
                console.log("添加新词段后，词段数:", wordSegments.length);

            // 确保有会话ID
            if (uploadSessionId === null) {
                    uploadSessionId = generateConsistentSessionId();
                }
                
                // 获取音频块并处理上传
                try {
                    let audioChunks = null;
                    
                    try {
                        audioChunks = recorder.getAudioChunks();
                        console.log("成功获取音频块:", audioChunks ? `大小: ${audioChunks.size}字节` : "无音频数据");
                    } catch (audioError) {
                        console.error("获取音频块失败:", audioError);
                    }
                    
            if (audioChunks) {
                if (isLastWord && isCompleteButton) {
                    // 如果是最后一个单词且按钮是"完成"状态，上传最终块并触发拼接
                            console.log("最后一个单词，上传最终块");
                    uploadFinalChunk(audioChunks);
                    
                    // 停止录音
                    if (recorder.isRecording) {
                        recorder.stop();
                    }
                } else {
                    // 正常上传当前音频块
                            console.log(`上传单词 "${word}" 的音频块`);
                    uploadWordAudioChunk(audioChunks, newSegment);
                }
                    } else {
                        // 如果没有音频数据，记录警告但继续处理
                        console.warn("没有获取到音频数据，但继续处理UI更新");
                    }
                } catch (error) {
                    console.error("处理音频块时出错:", error);
                }
            } else {
                console.log("录音暂停中或其他状态，跳过添加新标记和上传音频");
            }
            
            // 确保索引增量正确
            // 保存旧索引，用于检查
            const oldIndex = currentWordIndex;
            
            // 更新索引 - 重要：确保索引只增加1
        if (!isLastWord) {
                // 确保只增加1
                currentWordIndex = oldIndex + 1;
                console.log(`索引增加1: ${oldIndex} -> ${currentWordIndex}`);
        } else if (!isCompleteButton) {
            // 如果是最后一个单词但按钮不是"完成"状态，移动到下一个（循环到开头）
            currentWordIndex = 0;
                console.log(`循环回到首位: ${oldIndex} -> ${currentWordIndex}`);
            } else {
                // 保持不变
                console.log(`最后一个单词且按钮是完成状态，索引保持不变: ${currentWordIndex}`);
            }
            
            // 再次验证索引有效性
            if (currentWordIndex >= allWords.length) {
                console.error(`索引越界! 强制修正: ${currentWordIndex} -> ${oldIndex + 1 < allWords.length ? oldIndex + 1 : oldIndex}`);
                currentWordIndex = oldIndex + 1 < allWords.length ? oldIndex + 1 : oldIndex;
            }
            
            console.log(`索引最终设置为: ${currentWordIndex}`);
        
        // 更新单词显示
        updateWordDisplay();
        
        // 更新单词标记区
        updateMarkersList();
        
        // 保存录音进度
        saveRecordingProgress();
            
            // 记录最终索引，确认没有跳跃
            console.log(`[${callTime}] nextWord函数执行完毕，起始索引: ${startIndex}, 结束索引: ${currentWordIndex}`);
        } catch (error) {
            console.error("nextWord执行出错:", error);
        } finally {
            // 重置处理标记
            setTimeout(() => {
                isNextWordProcessing = false;
                console.log("nextWord函数处理标记已重置，可以再次调用");
            }, 100);
        }
    }
    
    // 上传单词对应的音频块
    function uploadWordAudioChunk(audioBlob, wordSegment) {
        if (!audioBlob) {
            console.warn('无音频数据，跳过上传');
            isUploading = false;
            return;
        }
        
        if (isUploading) {
            console.warn('正在上传中，跳过本次上传');
            return;
        }
        
        // 检查音频数据是否有效
        if (audioBlob.size === 0) {
            console.warn('音频数据大小为0，跳过上传');
            isUploading = false;
            return;
        }
        
        // 标记上传状态，避免重复上传
        isUploading = true;
        
        // 创建FormData对象
        const formData = new FormData();
        formData.append('audio_chunk', audioBlob, `chunk_${wordSegment.word}.wav`);
        formData.append('session_id', uploadSessionId);
        formData.append('chunk_index', wordSegments.length);
        
        // 收集当前词段信息
        const currentSegment = {
            word: wordSegment.word,
            startTime: wordSegment.startTime,
            endTime: wordSegment.endTime,
            duration: wordSegment.duration,
            speed: wordSegment.speed || '正常'
        };
        formData.append('current_segment', JSON.stringify(currentSegment));
        
        // 添加是否是最终块的标志（这里为false，因为是流式上传）
        formData.append('is_final', 'false');
        
        console.log(`正在上传单词 "${wordSegment.word}" 的音频数据，大小: ${audioBlob.size}字节...`);
        
        // 发送请求
        fetch('/api/upload_chunk', {
            method: 'POST',
            body: formData
        })
        .then(response => {
            if (!response.ok) {
                return response.text().then(text => {
                    throw new Error(`单词音频上传失败 (${response.status}): ${text}`);
                });
            }
            return response.json();
        })
        .then(data => {
            console.log(`单词 "${wordSegment.word}" 音频上传成功:`, data);
            // 重置上传状态
            isUploading = false;
            
            // 保存进度以防后续中断
            saveRecordingProgress();
        })
        .catch(error => {
            console.error(`单词 "${wordSegment.word}" 音频上传错误:`, error);
            isUploading = false;
            
            // 显示错误但不中断录音流程
            showMessage(window.i18n.translate('uploadError'), 'error');
            
            // 尽管上传失败，仍然保存本地进度
            saveRecordingProgress();
        });
    }
    
    // 上传最终音频块并触发服务器拼接
    function uploadFinalChunk(audioBlob) {
        if (!audioBlob || isUploading || isSubmitted) return;
        
        // 标记上传状态，避免重复上传
        isUploading = true;
        // 标记为已提交，防止再次上传
        isSubmitted = true;
        
        // 显示加载指示器
        showLoadingIndicator();
        
        // 创建FormData对象
        const formData = new FormData();
        formData.append('audio_chunk', audioBlob, 'final_chunk.wav');
        formData.append('session_id', uploadSessionId);
        formData.append('chunk_index', wordSegments.length);
        formData.append('is_final', 'true');
        
        // 添加设备信息
        const deviceInfo = collectDeviceInfo();
        
        // 为所有词段准备完整的元数据
        const formattedSegments = wordSegments.map(segment => ({
            word: segment.word,
            startTime: segment.startTime,
            endTime: segment.endTime,
            duration: segment.duration,
            speed: segment.speed || '正常'
        }));
        
        // 创建完整的元数据
        const metadata = {
            wordSegments: formattedSegments,
            audioFormat: {
                sampleRate: 16000,
                bitDepth: 16,
                channels: 1
            },
            deviceInfo: deviceInfo,
            recordingStats: {
                totalDuration: recorder.getCurrentTime(),
                segmentsCount: wordSegments.length,
                recordingStartTime: new Date().toISOString()
            },
            platform: platform
        };
        
        // 只有在Prolific平台时才添加Prolific相关信息
        if (platform === 'prolific') {
            const prolificParamsEl = document.getElementById('prolific-params');
            if (prolificParamsEl) {
                metadata.prolificPID = prolificParamsEl.getAttribute('data-prolific-pid') || '';
                metadata.prolificStudyID = prolificParamsEl.getAttribute('data-prolific-study-id') || '';
                metadata.prolificSessionID = prolificParamsEl.getAttribute('data-prolific-session-id') || '';
                metadata.completionCode = 'C15MASW8';
            }
        }
        
        // 将完整元数据添加到表单
        formData.append('metadata', JSON.stringify(metadata));
        
        console.log('上传最终音频块并触发拼接...');
        
        // 设置请求超时为30秒
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), 30000);
        
        // 发送请求
        fetch('/api/upload_chunk', {
            method: 'POST',
            body: formData,
            signal: controller.signal
        })
        .then(response => {
            clearTimeout(timeoutId);
            hideLoadingIndicator();
            
            if (!response.ok) {
                return response.text().then(text => {
                    throw new Error(`最终块上传失败 (${response.status}): ${text}`);
                });
            }
            return response.json();
        })
        .then(data => {
            console.log('最终块上传成功，服务器已拼接音频:', data);
            
            // 处理完成后的UI更新
            handleUploadSuccess(data);
            
            // 如果在Prolific平台，创建重定向URL
            if (platform === 'prolific') {
                // 默认的完成代码，确保总有一个可用
                const defaultCompletionCode = 'C15MASW8';
                let prolificRedirectUrl = null;
                
                try {
                    // 尝试从不同的返回数据格式中获取跳转URL
                    if (data && data.completion_code) {
                        // 如果直接返回了完成代码
                        prolificRedirectUrl = `https://app.prolific.com/submissions/complete?cc=${data.completion_code}`;
                        console.log('从completion_code构建跳转URL:', prolificRedirectUrl);
                    } else if (data && data.completionUrl) {
                        // 如果返回了完整的跳转URL
                        prolificRedirectUrl = data.completionUrl;
                        console.log('使用服务器返回的completionUrl:', prolificRedirectUrl);
                    } else if (metadata && metadata.completionCode) {
                        // 使用元数据中的完成代码
                        prolificRedirectUrl = `https://app.prolific.com/submissions/complete?cc=${metadata.completionCode}`;
                        console.log('使用元数据中的completionCode构建跳转URL:', prolificRedirectUrl);
                    } else {
                        // 使用默认的完成代码
                        prolificRedirectUrl = `https://app.prolific.com/submissions/complete?cc=${defaultCompletionCode}`;
                        console.log('使用默认completionCode构建跳转URL:', prolificRedirectUrl);
                    }
                    
                    // 如果没有成功构建URL，使用默认完成代码
                    if (!prolificRedirectUrl) {
                        prolificRedirectUrl = `https://app.prolific.com/submissions/complete?cc=${defaultCompletionCode}`;
                        console.log('使用默认completionCode构建跳转URL:', prolificRedirectUrl);
                    }
                } catch (error) {
                    console.error('构建Prolific跳转URL出错:', error);
                    // 出错时使用默认完成代码
                    prolificRedirectUrl = `https://app.prolific.com/submissions/complete?cc=${defaultCompletionCode}`;
                    console.log('出错后使用默认completionCode构建跳转URL:', prolificRedirectUrl);
                }
                
                // 确保始终有一个有效的URL
                if (!prolificRedirectUrl) {
                    prolificRedirectUrl = `https://app.prolific.com/submissions/complete?cc=${defaultCompletionCode}`;
                }
                
                // 弹出alert提示录音完成，并在用户点击确定后立即跳转
                alert('录音已成功完成！点击确定返回Prolific。');
                
                // 直接跳转，无需等待
                try {
                    window.location.href = prolificRedirectUrl;
                } catch (e) {
                    console.error('跳转到Prolific失败:', e);
                    alert('跳转失败，请点击确定重试');
                    window.location.href = prolificRedirectUrl;
                }
            } else {
                // 如果不是Prolific平台，只弹出提示
                alert('录音已成功完成！');
            }
        })
        .catch(error => {
            clearTimeout(timeoutId);
            console.error('最终块上传错误:', error);
            hideLoadingIndicator();
            showMessage(window.i18n.translate('uploadError'), 'error');
            isUploading = false;
            // 失败时重置提交状态
            isSubmitted = false;
        });
    }
    
    // 更新录音时间显示
    function updateRecordingTime(time) {
        // 更新当前时间显示
        if (currentTimeEl) {
            currentTimeEl.textContent = formatTime(time);
        }
        
        // 如果总时间为0且有波形图，从波形图获取总时间
        if (totalTimeEl && (!totalTimeEl.textContent || totalTimeEl.textContent === '00:00') && waveform && waveform.wavesurfer) {
            const duration = waveform.wavesurfer.getDuration() || 0;
            if (duration > 0) {
                totalTimeEl.textContent = formatTime(duration);
            }
        }
    }
    
    // 处理录音错误
    function handleRecordError(error) {
        if (window.appConfig && window.appConfig.debugMode) {
            console.error('录音错误:', error);
        }
        alert(window.i18n.translate('recordingError'));
    }
    
    // 在上传过程中显示加载指示器
    function showLoadingIndicator() {
        if (loadingIndicator) {
            loadingIndicator.style.display = 'block';
        }
    }
    
    // 隐藏加载指示器
    function hideLoadingIndicator() {
        if (loadingIndicator) {
            loadingIndicator.style.display = 'none';
        }
    }
    
    // 显示临时消息提示
    function showMessage(text, type = 'info', duration = 3000) {
        // 确保有文本内容
        if (!text) return;
        
        // 移除之前存在的消息元素
        const existingMessages = document.querySelectorAll('.message');
        existingMessages.forEach(msg => msg.remove());
        
        // 创建消息元素
        const messageEl = document.createElement('div');
        messageEl.className = `message ${type}`;
        messageEl.textContent = text;
        document.body.appendChild(messageEl);
        
        // 显示消息
        setTimeout(() => {
            messageEl.classList.add('show');
        }, 10);
        
        // 设置定时器自动消失
        setTimeout(() => {
            messageEl.classList.remove('show');
            // 消息隐藏后移除元素
            setTimeout(() => {
                if (messageEl.parentNode) {
                    messageEl.parentNode.removeChild(messageEl);
                }
            }, 300);
        }, duration);
    }
    
    // 处理上传成功
    function handleUploadSuccess(data) {
        // 禁用录音按钮，防止重复录音
        recordBtn.disabled = true;
        recordBtn.style.opacity = '0.5';
        recordBtn.style.cursor = 'not-allowed';
        
        // 禁用上一词和下一词按钮
        prevBtn.disabled = true;
        nextBtn.disabled = true;
        prevBtn.style.opacity = '0.5';
        nextBtn.style.opacity = '0.5';
        
        // 移除Toast消息，改为alert弹窗
        // showMessage(window.i18n.translate('recordingComplete'), 'success');
        
        // 清除进度记录
        clearRecordingProgress();
        
        // 不再清除会话ID，让刷新后使用相同的ID
        // clearSessionId();
        
        console.log("录音已成功上传和处理，会话已完成", data);
    }
    
    // 创建录音器实例
    async function createRecorder() {
        try {
            // 如果已经有录音器实例，先重置
            if (recorder) {
                recorder.reset();
                return true;
            }
            
            // 初始化录音器
            recorder = new AudioRecorder({
                sampleRate: 16000,
                bitDepth: 16,
                channels: 1,
                onStart: handleRecordStart,
                onPause: handleRecordPause,
                onResume: handleRecordResume,
                onStop: handleRecordStop,
                onError: handleRecordError,
                onStateChange: handleRecordStateChange,
                onDataAvailable: function(data) {
                    // 数据可用时的处理
                    updateVUMeter(data);
                },
                onNewChunks: function(wavBlob, processed, total) {
                    // 不执行任何上传操作，只记录日志
                    console.log('新的音频块可用，等待点击下一词时上传');
                }
            });
            
            console.log('录音器已创建');
            return true;
        } catch (error) {
            console.error('创建录音器失败:', error);
            return false;
        }
    }
    
    // 切换录音状态（开始/暂停/恢复）
    function toggleRecording() {
        console.log('触发录音按钮点击事件');
        console.log('当前录音状态:', recorder.isRecording ? '正在录音' : '未录音');
        
        // 如果正在上传，不允许操作
        if (isUploading) {
            console.log('正在上传，忽略录音按钮点击');
            return;
        }
        
        // 如果已经提交过录音，不允许再次录音
        if (isSubmitted) {
            console.log('已提交录音，忽略录音按钮点击');
            alert(window.i18n.translate('alreadySubmitted') || '已经提交过录音，请刷新页面开始新的录音');
            return;
        }
        
        // 实现录音状态切换逻辑
        if (recorder.isRecording) {
            console.log('暂停录音...');
            recorder.pause();
        } else if (recorder.isPaused || (recorder.audioWorkletNode || recorder.audioProcessor || recorder.scriptProcessor)) {
            console.log('恢复录音...');
            recorder.resume();
        } else {
            console.log('开始新录音...');
            startRecording();
        }
    }
    
    init();
}); 